home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / Anwendun / 7UP_PD / FKEYS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-17  |  16.3 KB  |  695 lines
  1. /* Funktionstastenbelegung */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                        Modul: FKEYS.C
  6. *                                     (c) by TheoSoft '91
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <aes.h>
  15. #if GEMDOS
  16. #include <tos.h>
  17. #endif
  18.  
  19. #include "alert.h"
  20. #include "windows.h"
  21. #include "forms.h"
  22. #include "7UP.h"
  23.  
  24. #include "language.h"
  25. #include "undo.h"
  26.  
  27. #define F1     0x803B
  28. #define F10     0x8044
  29. #define SF1     0x8254 /*11.6.94 Bugfix*/
  30. #define SF10 0x825D
  31. #define ESC     27
  32. #define TAB     9
  33. #define CR   0x0D
  34.  
  35. char *expandfkey(WINDOW *wp, char *str, int page);
  36. void hndl_fkeymenu(OBJECT *tree, int start);
  37. char *split_fname(char *name);
  38. int fkeys(WINDOW *wp, int ks, int kr, LINESTRUCT **begcut, LINESTRUCT **endcut);
  39.  
  40. extern OBJECT *fkeymenu;
  41. extern char alertstr[],iostring[];
  42. extern int windials;
  43.  
  44. static char fkeystat[10]=
  45. {
  46.     FALSE,
  47.     FALSE,
  48.     FALSE,
  49.     FALSE,
  50.     FALSE,
  51.     FALSE,
  52.     FALSE,
  53.     FALSE,
  54.     FALSE,
  55.     FALSE
  56. };
  57.  
  58. static char sfkeystat[10]=
  59. {
  60.     FALSE,
  61.     FALSE,
  62.     FALSE,
  63.     FALSE,
  64.     FALSE,
  65.     FALSE,
  66.     FALSE,
  67.     FALSE,
  68.     FALSE,
  69.     FALSE
  70. };
  71.  
  72. static char *dayoftheweek[]=
  73. {
  74.     SONNTAG,
  75.     MONTAG,
  76.     DIENSTAG,
  77.     MITTWOCH,
  78.     DONNERSTAG,
  79.     FREITAG,
  80.     SONNABEND
  81. };
  82.  
  83. char *datetime(char what)
  84. {
  85.     long timer;
  86.     struct tm *tp;
  87.     static char str[16]="";
  88.  
  89.     time(&timer);
  90.     tp=localtime(&timer);
  91.     switch(what)
  92.     {
  93.         case 's':
  94.             sprintf(str,"%02d",tp->tm_sec);
  95.             break;
  96.         case 'm':
  97.             sprintf(str,"%02d",tp->tm_min);
  98.             break;
  99.         case 'h':
  100.             sprintf(str,"%02d",tp->tm_hour);
  101.             break;
  102.         case 'T':
  103.             sprintf(str,"%02d",tp->tm_mday);
  104.             break;
  105.         case 'M':
  106.             sprintf(str,"%02d",tp->tm_mon+1);
  107.             break;
  108.         case 'J':
  109.             sprintf(str,"%d",tp->tm_year);
  110.             break;
  111.         case 'W':
  112.             sprintf(str,"%s",dayoftheweek[tp->tm_wday]);
  113.             break;
  114.         case 'D':
  115.             sprintf(str,"%d",tp->tm_yday+1);
  116.             break;
  117.     }
  118.     return(str);
  119. }
  120.  
  121. char *expandfkey(WINDOW *wp, char *string, int page)
  122. {
  123.     register int i,k;
  124.     char code, expanded[161];
  125.  
  126.     k=strlen(string);
  127.     strcpy(expanded,string);
  128.  
  129.     for(i=0; i<k; i++)
  130.     {
  131.         if(expanded[i]=='%')
  132.         {
  133.             switch(code=expanded[i+1])
  134.             {
  135.                 case 's':
  136.                 case 'm':
  137.                 case 'h':
  138.                 case 'T':
  139.                 case 'M':
  140.                 case 'J':
  141.                 case 'W':
  142.                 case 'D':
  143.                     if(!expanded[i+2])
  144.                         strcpy(&expanded[i],datetime(code));
  145.                     else
  146.                     {
  147.                         strcpy(&expanded[i],&expanded[i+2]);
  148.                         strins(expanded,datetime(code),i);
  149.                         k+=(strlen(datetime(code))-2);
  150.                     }
  151.                     break;
  152.                 case 'F':                      /* Pfadname */
  153.                     if(!expanded[i+2])
  154.                         strcpy(&expanded[i],(char *)Wname(wp));
  155.                     else
  156.                     {
  157.                         strcpy(&expanded[i],&expanded[i+2]);
  158.                         strins(expanded,(char *)Wname(wp),i);
  159.                         k+=(strlen((char *)Wname(wp))-2);
  160.                     }
  161.                     break;
  162.                 case 'f':                     /* Name */
  163.                     strcpy(iostring,(char *)split_fname((char *)Wname(wp)));
  164.                     if(!expanded[i+2])
  165.                         strcpy(&expanded[i],iostring);
  166.                     else
  167.                     {
  168.                         strcpy(&expanded[i],&expanded[i+2]);
  169.                         strins(expanded,iostring,i);
  170.                         k+=(strlen(iostring)-2);
  171.                     }
  172.                     break;
  173.                 case 'p':
  174.                     itoa(page,iostring,10);
  175.                     if(!expanded[i+2])
  176.                         strcpy(&expanded[i],iostring);
  177.                     else
  178.                     {
  179.                         strcpy(&expanded[i],&expanded[i+2]);
  180.                         strins(expanded,iostring,i);
  181.                         k+=(strlen(iostring)-2);
  182.                     }
  183.                     break;
  184.                 case '%':
  185.                     strcpy(&expanded[i],&expanded[i+1]);
  186.                     k--;
  187.                     break;
  188.                 default:
  189.                     break;
  190.             }
  191.         }
  192.     }
  193.     strcpy(string, expanded);
  194.     return(string);
  195. }
  196. /*
  197. void _keyoff(void);
  198. void _keyon(void);
  199. */
  200. int newfkey(char c)
  201. {
  202.     register int i=0;
  203.     switch(c)
  204.     {
  205.         case '0':
  206.             i++;
  207.         case '9':
  208.             i++;
  209.         case '8':
  210.             i++;
  211.         case '7':
  212.             i++;
  213.         case '6':
  214.             i++;
  215.         case '5':
  216.             i++;
  217.         case '4':
  218.             i++;
  219.         case '3':
  220.             i++;
  221.         case '2':
  222.             i++;
  223.         case '1':
  224.             return(i);
  225.             break;
  226.     }
  227.     return(-1);
  228. }
  229.  
  230. int newkey(int c1, int c2, int *state, int *key)
  231. {
  232.     switch(c1)
  233.     {
  234.         case 'A':
  235.         case 'a':
  236.             *state=K_ALT;
  237.             *key=c2;
  238.             break;
  239.         case 'C':
  240.         case 'c':
  241.             *state=K_CTRL;
  242.             *key=c2;
  243.             break;
  244.     }
  245. }
  246.  
  247. int fkeys(WINDOW *wp, int ks, int kr, LINESTRUCT **begcut, LINESTRUCT **endcut)
  248. {
  249.     char *str,fstr[161];
  250.     register int key,i,k,m,ret=FALSE;
  251.     int nstate,nkey,fkey=0;
  252.     
  253.     if(wp && (kr & 0x8000))/* Scancodebit muß gesetzt sein */
  254.     {
  255.         if(kr>=F1 && kr<=F10)
  256.         {
  257.             key=(kr)-(F1);
  258.             fkeystat[key]=TRUE;
  259.             if(str=expandfkey(wp,form_read(fkeymenu,FKEY1+key,fstr),0))
  260.             {
  261.                 k=strlen(str);
  262.                 if(k)
  263.                 {
  264.                     for(i=0; i<k; i++)
  265.                     {
  266.                         switch(str[i])
  267.                         {
  268.                             case '\\':
  269.                                 switch(str[i+1])
  270.                                 {
  271.                                     case 'C': /* Cntrl ? */
  272.                                     case 'c': /* Cntrl ? */
  273.                                     case 'A': /* Alt ? */
  274.                                     case 'a': /* Alt ? */
  275.                                         newkey(__toupper(str[i+1]),__toupper(str[i+2]),&nstate,&nkey);
  276.                                         hndl_keybd(nstate,nkey);
  277.                                         break;
  278.                                     case 'f':
  279.                                         if((fkey=newfkey(str[i+2]))>=0)
  280.                                         {
  281.                                             if(!fkeystat[fkey])
  282.                                             {
  283.                                                 fkeystat[fkey]=TRUE;
  284.                                                 fkeys(wp,0,((F1)+fkey),begcut,endcut);
  285.                                                 fkeystat[fkey]=FALSE;
  286.                                             }
  287.                                             i+=2;
  288.                                         }
  289.                                         else
  290.                                             editor(wp,0,(int)str[i],begcut,endcut);
  291.                                         break;
  292.                                     case 'F':
  293.                                         if((fkey=newfkey(str[i+2]))>=0)
  294.                                         {
  295.                                             if(!sfkeystat[fkey])
  296.                                             {
  297.                                                 sfkeystat[fkey]=TRUE;
  298.                                                 fkeys(wp,K_LSHIFT,((SF1)+fkey),begcut,endcut);
  299.                                                 sfkeystat[fkey]=FALSE;
  300.                                             }
  301.                                             i+=2;
  302.                                         }
  303.                                         else
  304.                                             editor(wp,0,(int)str[i],begcut,endcut);
  305.                                         break;
  306.                                     case 't':/* Text hinzuladen */
  307. /* MT 18.6.95 */
  308.                                         if(!*begcut && !*endcut)
  309.                                         {
  310.                                             switch(_read_blk(wp, &str[i+2], begcut, endcut))
  311.                                             {
  312.                                                 case -1:    /* kein ram frei */
  313.                                                     sprintf(alertstr,Afkeys[1],split_fname(&str[i+2]));
  314.                                                     form_alert(1,alertstr); /* kein break, es geht weiter */
  315.                                                 case TRUE: /* ok */
  316.                                                     store_undo(wp, &undo, *begcut, *endcut, WINEDIT, EDITCUT);
  317.                                                     wp->w_state|=CHANGED;
  318.                                                     m=(*endcut)->used; /* merken, wird benötigt, geht aber verloren */
  319.                                                     graf_mouse(M_OFF,0L);
  320.                                                     Wcursor(wp);
  321.                                                     if((wp->w_state&COLUMN))
  322.                                                         paste_col(wp,*begcut,*endcut);
  323.                                                     else
  324.                                                         paste_blk(wp,*begcut,*endcut);
  325.                                                     Wcursor(wp);
  326.                                                     graf_mouse(M_ON,0L);
  327.                                                     (*endcut)->endcol=m;
  328.                                                     if(!(wp->w_state&COLUMN))
  329.                                                         hndl_blkfind(wp,*begcut,*endcut,SEAREND);
  330.                                                     else
  331.                                                         free_blk(wp,*begcut); /* Spaltenblock freigeben */
  332.                                                     graf_mouse(M_OFF,0L);
  333.                                                     Wcursor(wp);
  334.                                                     Wredraw(wp,&wp->xwork);
  335.                                                     Wcursor(wp);
  336.                                                     graf_mouse(M_ON,0L);
  337.                                                     break;
  338.                                                 case FALSE:
  339.                                                     sprintf(alertstr,Afkeys[2],(char *)split_fname(&str[i+2]));
  340.                                                     form_alert(1,alertstr);
  341.                                                     undo.item=FALSE;    /* EDITCUT */
  342.                                                     break;
  343.                                             }
  344.                                             *begcut=*endcut=NULL;
  345.                                         }
  346.                                         return(TRUE);/* raus, sonst wird auch der Dateiname eingefügt */
  347.                                         break;
  348.                                     default:
  349.                                         editor(wp,0,(int)str[i],begcut,endcut);
  350.                                         break;
  351.                                 }
  352.                                 break;
  353.                             case TAB:
  354.                                 editor(wp,0,TAB,begcut,endcut);
  355.                                 break;
  356.                             case ESC:
  357.                                 editor(wp,0,ESC,begcut,endcut);
  358.                                 break;
  359.                             case '\r': /* ^M == CR berücksichtigen */
  360.                                 editor(wp,0,CR,begcut,endcut);
  361.                                 break;
  362.                             default:
  363.                                 editor(wp,0,(int)str[i],begcut,endcut);
  364.                                 break;
  365.                         }
  366.                     }
  367.                 }
  368.                 else
  369.                 {
  370.                     fkeymenu[FKNORM ].ob_flags&=~HIDETREE;
  371.                     fkeymenu[FKSHIFT].ob_flags|=HIDETREE;
  372.                     if((*begcut) && (*endcut) && (*begcut)==(*endcut) && (*endcut)->begcol<(*endcut)->used)
  373.                     {
  374.                         strncpy(alertstr,&(*begcut)->string[(*begcut)->begcol],(*begcut)->endcol-(*begcut)->begcol);
  375.                         alertstr[(*begcut)->endcol-(*begcut)->begcol]=0;
  376.                         alertstr[fkeymenu[FKEY1+key].ob_spec.tedinfo->te_txtlen-1]=0;
  377.                         form_write(fkeymenu,FKEY1+key,alertstr,FALSE);
  378.                     }
  379.                     hndl_fkeymenu(fkeymenu,FKEY1+key);
  380.                 }
  381.             }
  382.             fkeystat[key]=FALSE;
  383.             ret=TRUE;
  384.         }
  385.         if(kr>=SF1 && kr<=SF10)
  386.         {
  387.             key=(kr)-(SF1);
  388.             sfkeystat[key]=TRUE;
  389.             if(str=expandfkey(wp,form_read(fkeymenu,SFKEY1+key,fstr),0))
  390.             {
  391.                 k=strlen(str);
  392.                 if(k)
  393.                 {
  394.                     for(i=0; i<k; i++)
  395.                     {
  396.                         switch(str[i])
  397.                         {
  398.                             case '\\':
  399.                                 switch(str[i+1])
  400.                                 {
  401.                                     case 'C': /* Cntrl ? */
  402.                                     case 'c': /* Cntrl ? */
  403.                                     case 'A': /* Alt ? */
  404.                                     case 'a': /* Alt ? */
  405.                                         newkey(__toupper(str[i+1]),__toupper(str[i+2]),&nstate,&nkey);
  406.                                         hndl_keybd(nstate,nkey);
  407.                                         break;
  408.                                     case 'f':
  409.                                         if((fkey=newfkey(str[i+2]))>=0)
  410.                                         {
  411.                                             if(!fkeystat[fkey])
  412.                                             {
  413.                                                 fkeystat[fkey]=TRUE;
  414.                                                 fkeys(wp,0,((F1)+fkey),begcut,endcut);
  415.                                                 fkeystat[fkey]=FALSE;
  416.                                             }
  417.                                             i+=2;
  418.                                         }
  419.                                         else
  420.                                             editor(wp,0,(int)str[i],begcut,endcut);
  421.                                         break;
  422.                                     case 'F':
  423.                                         if((fkey=newfkey(str[i+2]))>=0)
  424.                                         {
  425.                                             if(!sfkeystat[fkey])
  426.                                             {
  427.                                                 sfkeystat[fkey]=TRUE;
  428.                                                 fkeys(wp,K_LSHIFT,((SF1)+fkey),begcut,endcut);
  429.                                                 sfkeystat[fkey]=FALSE;
  430.                                             }
  431.                                             i+=2;
  432.                                         }
  433.                                         else
  434.                                             editor(wp,0,(int)str[i],begcut,endcut);
  435.                                         break;
  436.                                     case 't':/* Text hinzuladen */
  437. /* MT 18.6.95 */
  438.                                         if(!*begcut && !*endcut)
  439.                                         {
  440.                                             switch(_read_blk(wp, &str[i+2], begcut, endcut))
  441.                                             {
  442.                                                 case -1:    /* kein ram frei */
  443.                                                     sprintf(alertstr,Afkeys[1],split_fname(&str[i+2]));
  444.                                                     form_alert(1,alertstr); /* kein break, es geht weiter */
  445.                                                 case TRUE: /* ok */
  446.                                                     store_undo(wp, &undo, *begcut, *endcut, WINEDIT, EDITCUT);
  447.                                                     wp->w_state|=CHANGED;
  448.                                                     m=(*endcut)->used; /* merken, wird benötigt, geht aber verloren */
  449.                                                     graf_mouse(M_OFF,0L);
  450.                                                     Wcursor(wp);
  451.                                                     if((wp->w_state&COLUMN))
  452.                                                         paste_col(wp,*begcut,*endcut);
  453.                                                     else
  454.                                                         paste_blk(wp,*begcut,*endcut);
  455.                                                     Wcursor(wp);
  456.                                                     graf_mouse(M_ON,0L);
  457.                                                     (*endcut)->endcol=m;
  458.                                                     if(!(wp->w_state&COLUMN))
  459.                                                         hndl_blkfind(wp,*begcut,*endcut,SEAREND);
  460.                                                     else
  461.                                                         free_blk(wp,*begcut); /* Spaltenblock freigeben */
  462.                                                     graf_mouse(M_OFF,0L);
  463.                                                     Wcursor(wp);
  464.                                                     Wredraw(wp,&wp->xwork);
  465.                                                     Wcursor(wp);
  466.                                                     graf_mouse(M_ON,0L);
  467.                                                     break;
  468.                                                 case FALSE:
  469.                                                     sprintf(alertstr,Afkeys[2],(char *)split_fname(&str[i+2]));
  470.                                                     form_alert(1,alertstr);
  471.                                                     undo.item=FALSE;    /* EDITCUT */
  472.                                                     break;
  473.                                             }
  474.                                             *begcut=*endcut=NULL;
  475.                                         }
  476.                                         return(TRUE);/* raus, sonst wird auch der Dateiname eingefügt */
  477.                                         break;
  478.                                     default:
  479.                                         editor(wp,0,(int)str[i],begcut,endcut);
  480.                                         break;
  481.                                 }
  482.                                 break;
  483.                             case TAB:
  484.                                 editor(wp,0,TAB,begcut,endcut);
  485.                                 break;
  486.                             case ESC:
  487.                                 editor(wp,0,ESC,begcut,endcut);
  488.                                 break;
  489.                             case '\r': /* ^M == CR berücksichtigen */
  490.                                 editor(wp,0,CR,begcut,endcut);
  491.                                 break;
  492.                             default:
  493.                                 editor(wp,0,(int)str[i],begcut,endcut);
  494.                                 break;
  495.                         }
  496.                     }
  497.                 }
  498.                 else
  499.                 {
  500.                     fkeymenu[FKNORM ].ob_flags|= HIDETREE;
  501.                     fkeymenu[FKSHIFT].ob_flags&=~HIDETREE;
  502.                     if((*begcut) && (*endcut) && (*begcut)==(*endcut) && (*endcut)->begcol<(*endcut)->used)
  503.                     {
  504.                         strncpy(alertstr,&(*begcut)->string[(*begcut)->begcol],(*begcut)->endcol-(*begcut)->begcol);
  505.                         alertstr[(*begcut)->endcol-(*begcut)->begcol]=0;
  506.                         alertstr[fkeymenu[SFKEY1+key].ob_spec.tedinfo->te_txtlen-1]=0;
  507.                         form_write(fkeymenu,SFKEY1+key,alertstr,FALSE);
  508.                     }
  509.                     hndl_fkeymenu(fkeymenu,SFKEY1+key);
  510.                 }
  511.             }
  512.             sfkeystat[key]=FALSE;
  513.             ret=TRUE;
  514.         }
  515.     }
  516.     return(ret);
  517. }
  518.  
  519. static void set_3D_flags(OBJECT *tree)
  520. {
  521.     int i;
  522.     
  523.     tree[FKSHIFT].ob_flags |= 0x0400;
  524.     tree[FKNORM ].ob_flags |= 0x0400;
  525.     for(i=0; i<10; i++)
  526.         tree[i+FKEY1].ob_flags |= 0x0400;
  527.     for(i=10; i<20; i++)
  528.         tree[i-10+SFKEY1].ob_flags |= 0x0400;
  529. }
  530.  
  531. void _savesoftkeys(char *pathname)
  532. {
  533.     FILE *fp;
  534.     int i;
  535.     
  536.     if((fp=fopen(pathname,"wb"))!=NULL)
  537.     {
  538.       graf_mouse(BUSY_BEE,NULL);
  539.         for(i=FKEY1; i<=FKEY10; i++)
  540.         {
  541.             fputs(form_read(fkeymenu,i,pathname),fp);      /* Fkttasten */
  542.             fputs("\r\n",fp);
  543.         }
  544.         for(i=SFKEY1; i<=SFKEY10; i++)
  545.         {
  546.             fputs(form_read(fkeymenu,i,pathname),fp);
  547.             fputs("\r\n",fp);
  548.         }
  549.         fclose(fp);
  550.       graf_mouse(ARROW,NULL);
  551.     }
  552. }
  553.  
  554. void _loadsoftkeys(char *pathname)
  555. {
  556.     FILE *fp;
  557.     int i;
  558.         
  559.     if((fp=fopen(pathname,"rb"))!=NULL)
  560.     {
  561.       graf_mouse(BUSY_BEE,NULL);
  562.         for(i=FKEY1; i<=FKEY10; i++)
  563.         {
  564.             fgets(pathname,64,fp);
  565.             pathname[strlen(pathname)-2]=0;
  566.             form_write(fkeymenu,i,pathname,FALSE);
  567.         }
  568.         for(i=SFKEY1; i<=SFKEY10; i++)
  569.         {
  570.             fgets(pathname,64,fp);
  571.             pathname[strlen(pathname)-2]=0;
  572.             form_write(fkeymenu,i,pathname,FALSE);
  573.         }
  574.         fclose(fp);
  575.       graf_mouse(ARROW,NULL);
  576.     }
  577. }
  578.  
  579. void loadsoftkeys(char *filename)
  580. {
  581.     char *cp,pathname[PATH_MAX];
  582.     
  583.    search_env(pathname,filename,FALSE); /* READ */
  584.     _loadsoftkeys(pathname);
  585. }
  586.  
  587. void hndl_fkeymenu(OBJECT *tree, int start)
  588. {
  589.     int x,y,exit_obj,i,done=FALSE;
  590.     char *cp,keys[20][33];
  591.  
  592.     char filename[PATH_MAX]="";
  593.     /*static*/ char fpattern[FILENAME_MAX]="*.*";
  594.  
  595.  
  596.     if(tree[FKSHIFT].ob_flags & HIDETREE)
  597.     {
  598.         form_write(tree,FKEYSHFT,MIT_SHIFT,FALSE);
  599.         if(!start)
  600.             start=FKEY1;
  601.     }
  602.     else
  603.     {
  604.         form_write(tree,FKEYSHFT,OHNE_SHIFT,FALSE);
  605.         if(!start)
  606.             start=SFKEY1;
  607.     }
  608.     for(i=0; i<10; i++)
  609.         form_read(tree,i+FKEY1,keys[i]);
  610.     for(i=10; i<20; i++)
  611.         form_read(tree,i-10+SFKEY1,keys[i]);
  612.    
  613.    set_3D_flags(tree);
  614.       
  615.       form_exopen(tree,0);
  616.     do
  617.     {
  618.         exit_obj=form_exdo(tree,start);
  619.         objc_offset(tree,ROOT,&x,&y);
  620.         switch(exit_obj)
  621.         {
  622.             case FKEYLOAD:
  623.                 strcpy(fpattern,"*.SFK");
  624.                 find_7upinf(filename,"SFK",TRUE);
  625.                 if((cp=strrchr(filename,'\\'))!=NULL || (cp=strrchr(filename,'/'))!=NULL)
  626.                     strcpy(&cp[1],fpattern);
  627.                 else
  628.                     *filename=0;
  629.                 if(getfilename(filename,fpattern,"@",fselmsg[9]))
  630.                     _loadsoftkeys(filename);
  631.                 tree[exit_obj].ob_state&=~SELECTED;
  632.                 objc_update(tree,ROOT,MAX_DEPTH); /* Alles zeichnen! */
  633.                 break;
  634.             case FKEYSAVE:
  635.                 strcpy(fpattern,"*.SFK");
  636.                 find_7upinf(filename,"SFK",TRUE);
  637.                 if((cp=strrchr(filename,'\\'))!=NULL || (cp=strrchr(filename,'/'))!=NULL)
  638.                     strcpy(&cp[1],fpattern);
  639.                 else
  640.                     *filename=0;
  641.                 if(getfilename(filename,fpattern,"@",fselmsg[8]))
  642.                     _savesoftkeys(filename);
  643.                 tree[exit_obj].ob_state&=~SELECTED;
  644.                 if(!windials)
  645.                     objc_update(tree,ROOT,MAX_DEPTH);
  646.                 else
  647.                     objc_update(tree,exit_obj,0);
  648.                 break;
  649.             case FKEYSHFT:
  650.                 tree[FKSHIFT].ob_flags^=HIDETREE;
  651.                 tree[FKNORM ].ob_flags^=HIDETREE;
  652.                 tree[exit_obj].ob_state&=~SELECTED;
  653.                 if(tree[FKSHIFT].ob_flags & HIDETREE)
  654.                 {
  655.                     for(i=FKEY1; i<=FKEY10; i++)
  656.                         tree[i].ob_flags |= EDITABLE;
  657.                     for(i=SFKEY1; i<=SFKEY10; i++)
  658.                         tree[i].ob_flags &= ~EDITABLE;
  659.                     form_write(tree,FKEYSHFT,MIT_SHIFT,TRUE);
  660.                     start=FKEY1;
  661.                     objc_update(tree,ROOT/*FKNORM*/,MAX_DEPTH);
  662.                 }
  663.                 else
  664.                 {
  665.                     for(i=FKEY1; i<=FKEY10; i++)
  666.                         tree[i].ob_flags &= ~EDITABLE;
  667.                     for(i=SFKEY1; i<=SFKEY10; i++)
  668.                         tree[i].ob_flags |=  EDITABLE;
  669.                     form_write(tree,FKEYSHFT,OHNE_SHIFT,TRUE);
  670.                     start=SFKEY1;
  671.                     objc_update(tree,ROOT/*FKSHIFT*/,MAX_DEPTH);
  672.                 }
  673.                 break;
  674.             case FKEYHELP:
  675.                 form_alert(1,Afkeys[0]);
  676.                 objc_change(tree,exit_obj,0,x,y,tree->ob_width,tree->ob_height,tree[exit_obj].ob_state&~SELECTED,TRUE);
  677.                 break;
  678.             case FKEYOK:
  679.             case FKEYABBR:
  680.                 done=TRUE;
  681.                 break;
  682.         }
  683.     }
  684.     while(!done);
  685.     form_exclose(tree,exit_obj,0);
  686.     if(exit_obj==FKEYABBR)
  687.     {
  688.         for(i=0; i<10; i++)
  689.             form_write(tree,i+FKEY1,keys[i],FALSE);
  690.         for(i=10; i<20; i++)
  691.             form_write(tree,i-10+SFKEY1,keys[i],FALSE);
  692.     }
  693. }
  694.  
  695.